home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Programming / JForth / JTools / Janim / decode.asm < prev    next >
Encoding:
Assembly Source File  |  1991-10-26  |  7.4 KB  |  249 lines
  1. \ JForth Port of Jim Kent's unvscomp.asm
  2. \ by Martin Kees
  3.  
  4. \ The original docs:
  5. \ unvscomp.asm  Copyright 1987 Dancing Flame all rights reserved.
  6. \
  7. \ This file contains a single function which is set up to be called from
  8. \ C.  Ie the parameters are on the stack instead of registers.
  9. \       decode_vkplane(in, out, linebytes)
  10. \ where in is a bit-plane's worth of vertical-byte-run-with-skips data
  11. \ and out is a bit-plane that STILL has the image from last frame on it.
  12. \ Linebytes is the number of bytes-per-line in the out bitplane, and it
  13. \ should certainly be noted that the external pointer variable ytable
  14. \ must be initialized to point to a multiplication table of
  15. \ 0*linebytes, 1*linebytes ... n*linebytes  before this routine is called.
  16. \ 
  17. \ The format of "in":
  18. \   Each column of the bitplane is compressed separately.  A 320x200
  19. \   bitplane would have 40 columns of 200 bytes each.  The linebytes
  20. \   parameter is used to count through the columns, it is not in the
  21. \   "in" data, which is simply a concatenation of columns.
  22. \
  23. \   Each columns is an op-count followed by a number of ops.
  24. \   If the op-count is zero, that's ok, it just means there's no change
  25. \   in this column from the last frame.
  26. \   The ops are of three classes, and followed by a varying amount of
  27. \   data depending on which class.
  28. \       1. Skip ops - this is a byte with the hi bit clear that says how many
  29. \          rows to move the "dest" pointer forward, ie to skip. It is non-
  30. \          zero
  31. \       2. Uniq ops - this is a byte with the hi bit set.  The hi bit is
  32. \          masked down and the remainder is a count of the number of bytes
  33. \          of data to copy literally.  It's of course followed by the
  34. \          data to copy.
  35. \       3. Same ops - this is a 0 byte followed by a count byte, followed
  36. \          by a byte value to repeat count times.
  37. \   Do bear in mind that the data is compressed vertically rather than
  38. \   horizontally, so to get to the next byte in the destination (out)
  39. \   we add linebytes instead of one!
  40.  
  41. \   XOR version is for AnimBrush support
  42.  
  43. anew TASK-DECODE
  44.  
  45. \ A2 = OUT
  46. \ A0 = IN
  47. \ A3 = YTABLE
  48. ASM DECODE_VKPLANE (  in out ytable --- , for anims )
  49.     movem.l    a2/a3/d5,-(rp)  ; save registers 
  50.     move.l    (dsp)+,a2
  51.     adda.l  a4,a2              \ a2 = absaddr bitmap
  52.     move.l    (dsp)+,a0
  53.     adda.l  a4,a0              \ a0 = absaddr delta plane data
  54.     move.l    d7,a3
  55.     adda.l  a4,a3              \ a3 = absaddr of ytable data
  56.     move.l  (a3),d2            \ d2 = linebytes
  57.     move.w    d2,d4    \ make a copy of linebytes to use as a counter
  58.     bra    1$    \ And go to the "columns" loop
  59.     
  60. 2$:    move.l    a2,a1     \ get copy of dest pointer
  61.     clr.w    d0      \ clear hi byte of op_count
  62.     move.b    (a0)+,d0  \ fetch number of ops in this column
  63.     bra    3$      \ and branch to the "op" loop.
  64.  
  65. 4$:    clr.w    d1      \ clear hi byte of op
  66.     move.b    (a0)+,d1  \ fetch next op
  67.     bmi    5$        \ if hi-bit set branch to "uniq" decoder
  68.     beq     6$      \ if it's zero branch to "same" decoder
  69.  
  70.               \ otherwise it's just a skip
  71.     add.w    d1,d1      \ use amount to skip as index into word-table
  72.     adda.w    0(a3,d1.w),a1
  73.     dbra.w    d0,4$     \ go back to top of op loop
  74.     bra    7$        \ go back to column loop
  75.  
  76.                 \ here we decode a "vertical same run"
  77. 6$:    move.b    (a0)+,d1  \ fetch the count
  78.     move.b    (a0)+,d3  \ fetch the value to repeat
  79.     move.w    d1,d5     \ and do what it takes to fall into a "tower"
  80.     asr.w    #3,d5     \ d5 holds # of times to loop through tower
  81.     and.w    #7,d1     \ d1 is the remainder
  82.     add.w    d1,d1
  83.     add.w    d1,d1
  84.     neg.w    d1
  85.     jmp    34(pc,d1.w)    \ why 34?  8*size of tower
  86.                     \ instruction pair, but the extra 2's
  87.                     \ pure voodoo.
  88. 8$:    move.b    d3,(a1)
  89.     adda.w    d2,a1
  90.     move.b    d3,(a1)
  91.     adda.w    d2,a1
  92.     move.b    d3,(a1)
  93.     adda.w    d2,a1
  94.     move.b    d3,(a1)
  95.     adda.w    d2,a1
  96.     move.b    d3,(a1)
  97.     adda.w    d2,a1
  98.     move.b    d3,(a1)
  99.     adda.w    d2,a1
  100.     move.b    d3,(a1)
  101.     adda.w    d2,a1
  102.     move.b    d3,(a1)
  103.     adda.w    d2,a1
  104.     dbra.w    d5,8$
  105.     dbra.w    d0,4$
  106.     bra.l    7$
  107.  
  108.                           \ here we decode a "unique" run
  109. 5$:    and.b    #$7f,d1   \ setting up a tower as above....
  110.     move.w    d1,d5
  111.     asr.w    #3,d5
  112.     and.w    #7,d1
  113.     add.w    d1,d1
  114.     add.w    d1,d1
  115.     neg.w    d1
  116.     jmp    34(pc,d1.w)
  117. 9$:    move.b    (a0)+,(a1)
  118.     adda.w    d2,a1
  119.     move.b    (a0)+,(a1)
  120.     adda.w    d2,a1
  121.     move.b    (a0)+,(a1)
  122.     adda.w    d2,a1
  123.     move.b    (a0)+,(a1)
  124.     adda.w    d2,a1
  125.     move.b    (a0)+,(a1)
  126.     adda.w    d2,a1
  127.     move.b    (a0)+,(a1)
  128.     adda.w    d2,a1
  129.     move.b    (a0)+,(a1)
  130.     adda.w    d2,a1
  131.     move.b    (a0)+,(a1)
  132.     adda.w    d2,a1
  133.     dbra.w    d5,9$      \ branch back up to "op" loop
  134. 3$:     dbra.w    d0,4$      \ branch back up to "column loop"
  135.  
  136.     \  now we've finished decoding a single column
  137. 7$:    addq.l    #1,a2  \ so move the dest pointer to next column
  138. 1$:    dbra.w    d4,2$  \ and go do it again what say?
  139.     movem.l    (rp)+,a2-a3/d5
  140.     move.l  (dsp)+,d7
  141. end-code
  142.  
  143.  
  144. ASM DECODE_XORVKPLANE ( in out ytable --- , for animbrushes )
  145.     movem.l    a2-a3/d5,-(rp)  ; save registers 
  146.     move.l    (dsp)+,a2
  147.     adda.l  a4,a2            \ a2 = absaddr bitmap
  148.     move.l    (dsp)+,a0
  149.     adda.l  a4,a0            \ a0 = absaddr delta plane data
  150.         move.l  d7,a3
  151.         adda.l  a4,a3            \ a3 = absaddr of ytable data
  152.     move.l    (a3),d2          \ d2 = linebytes
  153.     move.w    d2,d4    \ make a copy of linebytes to use as a counter
  154.     bra    1$    \ And go to the "columns" loop
  155.     
  156. 2$:    move.l    a2,a1     \ get copy of dest pointer
  157.     clr.w    d0      \ clear hi byte of op_count
  158.     move.b    (a0)+,d0  \ fetch number of ops in this column
  159.     bra    3$      \ and branch to the "op" loop.
  160.  
  161. 4$:    clr.w    d1      \ clear hi byte of op
  162.     move.b    (a0)+,d1  \ fetch next op
  163.     bmi    5$        \ if hi-bit set branch to "uniq" decoder
  164.     beq     6$      \ if it's zero branch to "same" decoder
  165.  
  166.               \ otherwise it's just a skip
  167.     add.w    d1,d1      \ use amount to skip as index into word-table
  168.     adda.w    0(a3,d1.w),a1
  169.     dbra.w    d0,4$     \ go back to top of op loop
  170.     bra    7$        \ go back to column loop
  171.  
  172.               \ here we decode a "vertical same run"
  173. 6$:    move.b    (a0)+,d1  \ fetch the count
  174.     move.b    (a0)+,d3  \ fetch the value to XOR!!!!!!!!!!!!!!!
  175.     move.w    d1,d5     \ and do what it takes to fall into a "tower"
  176.     asr.w    #3,d5     \ d5 holds # of times to loop through tower
  177.     and.w    #7,d1     \ d1 is the remainder
  178.     add.w    d1,d1
  179.     add.w    d1,d1
  180.     neg.w    d1
  181.     jmp    34(pc,d1.w)          \ why 34?  8*size of tower
  182.                                      \ instruction pair, but the extra 2's
  183.                                      \ pure voodoo.
  184. 8$:    eor.b    d3,(a1)
  185.     adda.w    d2,a1
  186.     eor.b    d3,(a1)
  187.     adda.w    d2,a1
  188.     eor.b    d3,(a1)
  189.     adda.w    d2,a1
  190.     eor.b    d3,(a1)
  191.     adda.w    d2,a1
  192.     eor.b    d3,(a1)
  193.     adda.w    d2,a1
  194.     eor.b    d3,(a1)
  195.     adda.w    d2,a1
  196.     eor.b    d3,(a1)
  197.     adda.w    d2,a1
  198.     eor.b    d3,(a1)
  199.     adda.w    d2,a1
  200.     dbra.w    d5,8$
  201.     dbra.w    d0,4$
  202.     bra.l    7$
  203.  
  204.                           \ here we decode a "unique" run
  205. 5$:    and.b    #$7f,d1   \ setting up a tower as above....
  206.     move.w    d1,d5
  207.     asr.w    #3,d5
  208.     and.w    #7,d1
  209.     add.w    d1,d1
  210.         move.w  d1,-(dsp)
  211.     add.w    d1,d1
  212.         add.w   (dsp)+,d1
  213.     neg.w    d1
  214.     jmp    50(pc,d1.w)    \ offset is 8*6 +2 bytes for the uniq tower
  215. 9$:    move.b    (a0)+,d1
  216.         eor.b   d1,(a1)
  217.     adda.w    d2,a1
  218.     move.b    (a0)+,d1
  219.         eor.b   d1,(a1)
  220.     adda.w    d2,a1
  221.     move.b    (a0)+,d1
  222.         eor.b   d1,(a1)
  223.     adda.w    d2,a1
  224.     move.b    (a0)+,d1
  225.         eor.b   d1,(a1)
  226.     adda.w    d2,a1
  227.     move.b    (a0)+,d1
  228.         eor.b   d1,(a1)
  229.     adda.w    d2,a1
  230.     move.b    (a0)+,d1
  231.     eor.b   d1,(a1)
  232.     adda.w    d2,a1
  233.     move.b    (a0)+,d1
  234.     eor.b   d1,(a1)
  235.     adda.w    d2,a1
  236.     move.b    (a0)+,d1
  237.     eor.b   d1,(a1)
  238.     adda.w    d2,a1
  239.     dbra.w    d5,9$      \ branch back up to "op" loop
  240. 3$:     dbra.w    d0,4$      \ branch back up to "column loop"
  241.  
  242.     \  now we've finished decoding a single column
  243. 7$:    addq.l    #1,a2  \ so move the dest pointer to next column
  244. 1$:    dbra.w    d4,2$  \ and go do it again what say?
  245.     movem.l    (rp)+,a2-a3/d5
  246.     move.l  (dsp)+,d7
  247. end-code
  248.  
  249.